/*
 * 文 件 名 : StringUtil.java
 * 版    权 : China Machi.Co.,Ltd.Copyright 2009-2011.All rights reserved
 * 描    述 : <描述>
 * 修 改 人 : 许洋
 * 修改时间 : 2011-2-11
 * 跟踪单号 : <跟踪单号>
 * 修改单号 : <修改单号>
 * 修改内容 : <修改内容>
 */
package com.fire8.dolphin.utils;

import java.io.UnsupportedEncodingException;
import java.text.DecimalFormat;
import java.util.HashMap;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


/**
 * String常用工具类<br>
 * String 属性处理实现工具类
 *
 * @author  许洋
 * @version [版本号,2011-2-11]
 * @see     [相关类/方法]
 * @since   [产品/模块]
 */
public final class StringUtil
{
    
    /**
     * 字符串常量GBK
     */
    private static final String GBK = "GBK";
    
    /**
     * <默认构造函数>防止实例化
     */
    private StringUtil()
    {
        
    }
    
    /**
     * 记录日志
     * <功能详细描述>
     * @param exception 异常
     * @param methodName 方法名
     * @param strParam 参数
     *
     * @author 许洋
     * @see [类、类#方法、类#成员]
     */
    private static void addLog(final Exception exception,
            final String methodName, final String strParam)
    {
        
    }
    
    /**
     * 将空值(null)转化成空字符串""
     * <功能详细描述>
     * @param value 字符串参数
     * @return ""
     *
     * @author 许洋
     * @see [类、类#方法、类#成员]
     */
    public static String nullToStr(final String value)
    {
        String str = value;
        if (str == null || "null".equals(str))
        {
            str = "";
        }
        return str;
    }
    
    /**
     * 字符串数组 转化为与逗号分隔的字符串<br>
     * 将字符数组用逗号拼装，输出一个字符串
     * @param strs 字符串数组参数
     * @return 用逗号分隔的字符串
     *
     * @author 许洋
     * @see [类、类#方法、类#成员]
     */
    public static String arryToString(final String[] strs)
    {
        final StringBuffer strTmp = new StringBuffer("");
        if (strs != null)
        {
            for (int i = 0; i < strs.length; i++)
            {
                if (i == 0)
                {
                    strTmp.append(strs[i]);
                }
                else
                {
                    strTmp.append(',');
                    strTmp.append(strs[i]);
                }
            }
        }
        
        return strTmp.toString();
    }
    
    /**
     * 将逗号分割的字符，转化为数组
     * <功能详细描述>
     * @param str 字符串参数
     * @return 字符串数组
     *
     * @author 许洋
     * @see [类、类#方法、类#成员]
     */
    public static String[] strToArry(final String str)
    {
        String[] strs = null;
        if (str != null)
        {
            strs = str.split(",");
        }
        return strs;
    }
    
    /**
     * 将 空格分割的字符串，转化为数组 主要用于标签处理
     * <功能详细描述>
     * @param str 字符串参数
     * @return 字符串数组
     *
     * @author 许洋
     * @see [类、类#方法、类#成员]
     */
    public static String[] strToArryBySpace(final String str)
    {
        String[] strs = null;
        String strTmp = str;
        if (strTmp != null)
        {
            strTmp = replaceAllSymbol(strTmp);
            strs = strTmp.split(" ");
        }
        return strs;
    }
    
    /**
     * 将字符串转换为GB2312编码
     * <功能详细描述>
     * @param str 字符串参数
     * @return 转换编码后的字符串
     *
     * @author 许洋
     * @see [类、类#方法、类#成员]
     */
    public static String converttoGB(final String str)
    {
        String strReturn = null;
        try
        {
            final byte abyte0[] = StringUtil.nullToStr(str)
                    .getBytes("ISO-8859-1");
            strReturn = new String(abyte0, "gb2312");
        }
        catch (Exception e)
        {
            addLog(e, "converttoGB", str);
            strReturn = str;
        }
        
        return strReturn;
    }
    
    /**
     * 将GBK字符串转换为UTF-8编码
     * <功能详细描述>
     * @param str 字符串参数
     * @return 转换编码后的字符串
     *
     * @author 许洋
     * @see [类、类#方法、类#成员]
     */
    public static String getGbktoUTF(final String str)
    {
        String strReturn = null;
        try
        {
            final byte abyte0[] = StringUtil.nullToStr(str).getBytes(GBK);
            strReturn = new String(abyte0, "utf8");
        }
        catch (Exception e)
        {
            addLog(e, "getGbktoUTF", str);
            strReturn = str;
        }
        
        return strReturn;
    }
    
    /**
     * 将字符串里的所有符号转换为空格
     * <功能详细描述>
     * @param str 字符串参数
     * @return 转换后的字符串
     *
     * @author 许洋
     * @see [类、类#方法、类#成员]
     */
    public static String replaceAllSymbol(final String str)
    {
        String strTmp = "";
        if (str != null)
        {
            strTmp = str;
            strTmp = strTmp.replace("~", " ")
                    .replace("`", " ")
                    .replace("!", " ")
                    .replace("@", " ")
                    .replace("#", " ")
                    .replace("$", " ")
                    .replace("%", " ")
                    .replace("^", " ")
                    .replace("&", " ")
                    .replace("*", " ")
                    .replace("(", " ")
                    .replace(")", " ")
                    .replace("|", " ")
                    .replace("\\", " ")
                    .replace("=", " ")
                    .replace("+", " ")
                    .replace("_", " ")
                    .replace("-", " ")
                    .replace("}", " ")
                    .replace("]", " ")
                    .replace("{", " ")
                    .replace("{", " ")
                    .replace(":", " ")
                    .replace(";", " ")
                    .replace("'", " ")
                    .replace("\"", " ")
                    .replace("?", " ")
                    .replace("/", " ")
                    .replace(".", " ")
                    .replace(">", " ")
                    .replace(",", " ")
                    .replace("<", " ")
                    .replace("＃", " ")
                    .replace("～", " ")
                    .replace("｀", " ")
                    .replace("！", " ")
                    .replace("＠", " ")
                    .replace("＄", " ")
                    .replace("％", " ")
                    .replace("＾", " ")
                    .replace("＆", " ")
                    .replace("＊", " ")
                    .replace("（", " ")
                    .replace("）", " ")
                    .replace("＿", " ")
                    .replace("－", " ")
                    .replace("＋", " ")
                    .replace("＝", " ")
                    .replace("＼", " ")
                    .replace("｜", " ")
                    .replace("｛", " ")
                    .replace("｝", " ")
                    .replace("［", " ")
                    .replace("］", " ")
                    .replace("＂", " ")
                    .replace("＇", " ")
                    .replace("；", " ")
                    .replace("：", " ")
                    .replace("？", " ")
                    .replace("、", " ")
                    .replace("》", " ")
                    .replace("。", " ")
                    .replace("，", " ")
                    .replace("《", " ")
                    .replace("　", " ");
            
        }
        
        return strTmp;
    }
    
    /**
     * 去除字符串数组中重复的字段
     * <功能详细描述>
     * @param array 字符串数组参数
     * @return 去除重复的字段后的字符串数组
     *
     * @author 许洋
     * @see [类、类#方法、类#成员]
     */
    public static String[] replaceSameWord(final String[] array)
    {
        Object[] key = null;
        String[] tempArray = null;
        if (array != null)
        {
            final HashMap<String, String> hashMap = new HashMap<String, String>();
            for (int i = 0; i < array.length; i++)
            {
                hashMap.put(array[i].trim(), array[i].trim());
            }
            final Set<String> set = hashMap.keySet();
            key = set.toArray();
            tempArray = new String[key.length];
            for (int i = 0; i < key.length; i++)
            {
                tempArray[i] = hashMap.get(key[i]);
                //System.out.println(key[i]+":"+hashMap.get(key[i]));
            }
        }
        return tempArray;
    }
    
    /**
     * 去除字符串中的空格、回车、换行符、制表符， 如： \n 该为换行，并截取指定长度
     * <功能详细描述>
     * @param source 字符串参数
     * @param length 要截取的长度
     * @return 转换后的字符串
     *
     * @author 许洋
     * @see [类、类#方法、类#成员]
     */
    public static String replaceToHtm(final String source, final int length)
    {
        final String strTmp = StringUtil.nullToStr(source);
        final Pattern pattern = Pattern.compile("\\s*|\t|\r|\n");
        final Matcher matcher = pattern.matcher(strTmp);
        final String after = matcher.replaceAll("");
        return after.substring(0, after.length() > length ? length - 1
                : after.length());
    }
    
    /**
     * 去除字符串中的空格、回车、换行符、制表符， 如： \n 改为换行
     * <功能详细描述>
     * @param source 字符串参数
     * @return 转换后的字符串
     *
     * @author 许洋
     * @see [类、类#方法、类#成员]
     */
    public static String replaceToHtm(final String source)
    {
        final String strTmp = StringUtil.nullToStr(source);
        final Pattern pattern = Pattern.compile("\\s*|\t|\r|\n");
        final Matcher matcher = pattern.matcher(strTmp);
        return matcher.replaceAll("");
    }
    
    /**
     * 将/r/n等转换为"< br>"代码
     * <功能详细描述>
     * @param str 字符串参数
     * @return 转换后的字符串
     *
     * @author 许洋
     * @see [类、类#方法、类#成员]
     */
    public static String convertHtml(final String str)
    {
        String strTmp = null;
        if (str != null && str.length() > 0)
        {
            strTmp = str;
            strTmp = strTmp.replace(" ", "&nbsp;")
                    .replace("\r\n", "<br>")
                    .replace("\n", "<br>");
        }
        
        return strTmp;
    }
    
    /**
     * 去掉html代码
     * <功能详细描述>
     * @param htmlStr HTML字符串参数
     * @return 去掉HTML代码后的字符串
     *
     * @author 许洋
     * @see [类、类#方法、类#成员]
     */
    public static String htmlToStr(final String htmlStr)
    {
        final StringBuffer resultBuffer = new StringBuffer("");
        boolean flag = true;
        if (htmlStr != null)
        {
            final char[] arr = htmlStr.toCharArray();
            final int length = arr.length;
            for (int i = 0; i < length; i++)
            {
                if (arr[i] == '<')
                {
                    flag = false;
                    continue;
                }
                if (arr[i] == '>')
                {
                    flag = true;
                    continue;
                }
                if (flag)
                {
                    resultBuffer.append(arr[i]);
                }
            }
        }
        
        return resultBuffer.toString();
    }
    
    /**
     * 格式化字符串 自增1 不够在前补0
     * <功能详细描述>
     * @param strNum 待格式化的字符串参数
     * @param format 格式化形式 “00000”
     * @return 格式化后的字符串
     *
     * @author 许洋
     * @see [类、类#方法、类#成员]
     */
    public static String formatIncStr(final String strNum, final String format)
    {
        Integer intNum = Integer.parseInt(strNum);
        intNum++;
        final DecimalFormat decimalFormat = new DecimalFormat(format);
        return decimalFormat.format(intNum);
    }
    
    /**
     * 格式化字符串 不够在前补0
     * <功能详细描述>
     * @param strNum 待格式化的字符串参数
     * @param format 格式化形式 “00000”
     * @return 格式化后的字符串
     *
     * @author 许洋
     * @see [类、类#方法、类#成员]
     */
    public static String formatStr(final String strNum, final String format)
    {
        final Integer intNum = Integer.parseInt(strNum);
        final DecimalFormat decimalFormat = new DecimalFormat(format);
        return decimalFormat.format(intNum);
    }
    
    /**
     *  验证字符串合法性
     * <功能详细描述>
     * @param txt  要验证的源字符串
     * @param regExc 正则表达式 
     * @param intParam 1为区分大小写 0为忽略大小写
     * @return true为验证成功
     *
     * @author 许洋
     * @see [类、类#方法、类#成员]
     */
    public static boolean matches(final String txt, final String regExc,
            final int intParam)
    {
        boolean isFlag = false;
        try
        {
            Pattern pattern = null; //正则表达式 
            Matcher matcher = null; //操作的字符串
            if (intParam == 1)
            {
                pattern = Pattern.compile(regExc);
            }
            else
            {
                pattern = Pattern.compile(regExc, Pattern.CASE_INSENSITIVE);
            }
            pattern = Pattern.compile(regExc);
            matcher = pattern.matcher(txt);
            if (matcher.matches())
            {
                isFlag = true;
            }
        }
        catch (Exception e)
        {
            addLog(e, "matches", null);
        }
        
        return isFlag;
    }
    
    /**
     * 字符串替换功能
     * <功能详细描述>
     * @param source  要替换的源字符串
     * @param regExc 正则表达式 
     * @param newstring 替换成新字符串
     * @param intParam 1为区分大小写 0为忽略大小写
     * @return 替换后的字符串
     *
     * @author 许洋
     * @see [类、类#方法、类#成员]
     */
    public static String replaceAll(final String source, final String regExc,
            final String newstring, final int intParam)
    {
        String strReturn = null;
        try
        {
            Pattern pattern = null; //正则表达式 
            Matcher matcher = null; //操作的字符串
            if (intParam == 1)
            {
                pattern = Pattern.compile(regExc);
            }
            else
            {
                pattern = Pattern.compile(regExc, Pattern.CASE_INSENSITIVE);
            }
            matcher = pattern.matcher(source);
            final boolean flag = matcher.find();
            if (flag)
            {
                strReturn = matcher.replaceAll(newstring);
            }
        }
        catch (Exception e)
        {
            addLog(e, "replaceAll", null);
        }
        
        return strReturn;
    }
    
    /**
     * 字符串加密
     * <功能详细描述>
     * @param strSrc 带加密字符串参数
     * @return 加密后的字符串
     *
     * @author 许洋
     * @see [类、类#方法、类#成员]
     */
    public static String escape(final String strSrc)
    {
        char chr;
        final StringBuffer tmp = new StringBuffer();
        tmp.ensureCapacity(strSrc.length() * 6);
        for (int i = 0; i < strSrc.length(); i++)
        {
            chr = strSrc.charAt(i);
            if (Character.isDigit(chr) || Character.isLowerCase(chr)
                    || Character.isUpperCase(chr))
            {
                tmp.append(chr);
            }
            else if (chr < 256)
            {
                tmp.append('%');
                if (chr < 16)
                {
                    tmp.append('0');
                }
                tmp.append(Integer.toString(chr, 16));
            }
            else
            {
                tmp.append("%u");
                tmp.append(Integer.toString(chr, 16));
            }
        }
        return tmp.toString();
    }
    
    /**
     * 字符串解密<br>
     * 使用escape(str)方法加密后，用该方法进行解密
     * @param strSrc 字符串参数
     * @return 解密后的字符串参数
     *
     * @author 许洋
     * @see [类、类#方法、类#成员]
     */
    public static String unescape(final String strSrc)
    {
        final StringBuffer tmp = new StringBuffer("");
        if (strSrc != null && strSrc.length() > 0)
        {
            tmp.ensureCapacity(strSrc.length());
            int lastPos = 0, pos = 0;
            char chr;
            while (lastPos < strSrc.length())
            {
                pos = strSrc.indexOf('%', lastPos);
                if (pos == lastPos)
                {
                    if (strSrc.charAt(pos + 1) == 'u')
                    {
                        chr = (char)Integer.parseInt(strSrc.substring(pos + 2,
                                pos + 6), 16);
                        tmp.append(chr);
                        lastPos = pos + 6;
                    }
                    else
                    {
                        chr = (char)Integer.parseInt(strSrc.substring(pos + 1,
                                pos + 3), 16);
                        tmp.append(chr);
                        lastPos = pos + 3;
                    }
                }
                else
                {
                    if (pos == -1)
                    {
                        tmp.append(strSrc.substring(lastPos));
                        lastPos = strSrc.length();
                    }
                    else
                    {
                        tmp.append(strSrc.substring(lastPos, pos));
                        lastPos = pos;
                    }
                }
            }
        }
        
        return tmp.toString();
    }
    
    /**
     * 针对javascript方法encodeURI()加密后的字符串进行解密
     * <功能详细描述>
     * @param str 字符串参数
     * @return 解密后的字符串
     * @throws UnsupportedEncodingException [参数说明]
     *
     * @author 许洋
     * @see [类、类#方法、类#成员]
     */
    public static String decode(final String str)
            throws UnsupportedEncodingException
    {
        String strReturn = "";
        if (str != null && str.length() > 0)
        {
            strReturn = java.net.URLDecoder.decode(str, GBK);
        }
        
        return strReturn;
    }
    
    /**
     * 转换字符串编码为UTF-8
     * <功能详细描述>
     * @param str 待转换字符串
     * @return 转换后字符串
     *
     * @author 许洋
     * @see [类、类#方法、类#成员]
     */
    public static String toUTF8(final String str)
    {
        
        String returnStr = null;
        try
        {
            returnStr = new String(str.getBytes("ISO8859_1"), "utf-8");
        }
        catch (UnsupportedEncodingException e)
        {
            addLog(e, "toUTF8", str);
            returnStr = "";
        }
        
        return returnStr;
    }
    
    /**
     * 判断字符串是否为null或空串
     * <功能详细描述>
     * @param str 待检验的字符串
     * @return boolean true为empty
     * 
     * @author 许洋
     * @see [类、类#方法、类#成员]
     */
    public static boolean isEmpty(final String str)
    {
        boolean isFlag = false;
        if (str == null || "".equals(str.trim()))
        {
            isFlag = true;
        }
        
        return isFlag;
    }
    
    /**
     * 判断字符是否为中文
     * <功能详细描述>
     * @param chr 字符参数
     * @return ture为中文
     *
     * @author 钟方杰
     * @see [类、类#方法、类#成员]
     */
    public static boolean isChinese(final char chr)
    {
        boolean isFlag = false;
        final Character.UnicodeBlock unicodeBlock = Character.UnicodeBlock.of(chr);
        if (unicodeBlock == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS
                || unicodeBlock == Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS
                || unicodeBlock == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A
                || unicodeBlock == Character.UnicodeBlock.GENERAL_PUNCTUATION
                || unicodeBlock == Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION
                || unicodeBlock == Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS)
        {
            isFlag = true;
        }
        return isFlag;
    }
    
    /**
     * 截取指定长度的字符串，截取后加上...<br>
     * 截取指定长度的字符串，能完整截取中文
     * @param strSrc 字符串参数
     * @param length 截取的长度
     * @return 截取后的字符串
     *
     * @author 许洋
     * @see [类、类#方法、类#成员]
     */
    public static String getSubString(final String strSrc, final int length)
    {
        return getSubString(strSrc, length, "...");
    }
    
    /**
     * 截取指定长度的字符串
     * 截取指定长度的字符串，能完整截取中文
     * @param strSrc 字符串参数
     * @param length 截取的长度
     * @param append 截取后在后面加上的字符串
     * @return 截取后的字符串
     *
     * @author 许洋
     * @see [类、类#方法、类#成员]
     */
    public static String getSubString(final String strSrc, final int length,
            final String append)
    {
        String strResult = "";
        int len = 0;
        final char[] chars = strSrc.toCharArray();
        final StringBuffer resultSB = new StringBuffer();
        int index = 0;
        while (len < length)
        {
            if (index >= chars.length)
            {
                strResult = resultSB.toString();
            }
            resultSB.append(chars[index]);
            if (chars[index++] > 0xff)
            {
                len += 2;
            }
            else
            {
                len++;
            }
        }
        if (!resultSB.toString().equals(strSrc))
        {
            resultSB.append(append);
        }
        strResult = resultSB.toString();
        
        return strResult;
    }
    
    /**
     * 去掉含有字符串的空格<br>
     * <功能详细描述>
     * @param str 字符串
     * @return 去掉含有字符串的空格
     *
     * @author 韦敏克
     * @see [类、类#方法、类#成员]
     */
    public static String trim(String str)
    {
        if (str != null)
        {
            str = str.replace(" ", "");
        }
        return str;
    }
    
    /**
     * 
     * 格式化金额
     * <功能详细描述>
     * @param daytime
     * @return [参数说明]
     *
     * @author 朱远海
     * @see [类、类#方法、类#成员]
     */
    public static String getMoneyForOther(Double daytime)
    {
        String result = "0";
        DecimalFormat df = new DecimalFormat(",###.0");
        if (!daytime.equals(0d))
        {
            result = df.format(daytime);
            if (result.startsWith("."))
            {
                result = "0" + result;
            }
        }
        
        return result;
    }
}
